package com.china08.yxyapi.service.manage.stu.mystudy.homework.dowork.impl;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

import com.china08.yxyapi.entity.es.ElasticYxyYxyQuesResource;
import com.china08.yxyapi.entity.mg.homework.HomeworkTask;
import com.china08.yxyapi.entity.mg.homework.HomeworkTaskClass;
import com.china08.yxyapi.entity.mg.homework.HomeworkTaskQues;
import com.china08.yxyapi.entity.mg.homework.HomeworkTaskQues.Article;
import com.china08.yxyapi.entity.mg.homework.HomeworkTaskReport;
import com.china08.yxyapi.entity.mg.homework.HomeworkTaskReportQues;
import com.china08.yxyapi.entity.mg.res.AllTemplate;
import com.china08.yxyapi.entity.mg.res.AllTemplate.Answer;
import com.china08.yxyapi.repository.es.ElasticYxyYxyQuesResourceRespository;
import com.china08.yxyapi.repository.mg.homework.HomeworkTaskClassRepository;
import com.china08.yxyapi.repository.mg.homework.HomeworkTaskQuesRepository;
import com.china08.yxyapi.repository.mg.homework.HomeworkTaskReportQuesRepository;
import com.china08.yxyapi.repository.mg.homework.HomeworkTaskReportRepository;
import com.china08.yxyapi.repository.mg.homework.HomeworkTaskRepository;
import com.china08.yxyapi.service.manage.stu.mystudy.homework.dowork.HomeworkSrevice;
import com.china08.yxyapi.service.manage.tec.teaching.homework.workcorrect.upd1.HomeworkCorrect1Service;
// import
// com.china08.yxyapi.service.manage.tec.teaching.homework.workcorrect1.HomeworkCorrect1Service;
import com.china08.yxyapi.util.DateAndLocalDateConvertUtils;

/***
 * 家庭作业service类 2017 年3月10日11:12:53**
 * 
 * @author lys
 **/
@Service
public class HomeworkServiceImpl implements HomeworkSrevice {

    @Autowired
    private HomeworkTaskReportQuesRepository htrqr;
    @Autowired
    private HomeworkTaskQuesRepository htqr;
    @Autowired
    private HomeworkTaskRepository htr;
    @Autowired
    private HomeworkTaskReportRepository htrr;
    @Autowired
    private ElasticYxyYxyQuesResourceRespository elasticYxyYxyQuesResourceRespository;
    @Autowired
    private HomeworkTaskClassRepository htcr;
    @Autowired
    HomeworkCorrect1Service homeworkCorrect1Service;

    // 用户提交一道 选择题 2017年4月21日10:57:18 重构
    @Override
    public boolean commitHomeworkForXZ(String studentId, String quesId, String answerOfMy, Integer duration,
            String taskId) {
        // 获取当前题的信息
        HomeworkTaskQues homeworkTaskQues = htqr.findByQuesIdAndTaskId(quesId, taskId).get(0);
        Assert.notNull(homeworkTaskQues, "提交的题没有找到！");
        // 获取当前任务的信息
        HomeworkTask homeworkTask = htr.findOne(taskId);
        Assert.notNull(homeworkTask, "作业信息获取失败");
        // 获取当前学生的作业报告信息
        HomeworkTaskReport htr = htrr.findByStudentIdAndTaskId(studentId, taskId);
        Assert.notNull(htr, "获取当前学生的作业报告信息失败，请联系管理员");
        Assert.isTrue(htr.getStatusOfFinished() == 3, "当前作业不是答题状态，无法提交");
        // 判断学生是否已经提交作业
        HomeworkTaskReportQues htrq = htrqr.findByStudentIdAndTaskIdAndQuesId(studentId, taskId, quesId);

        // 更新答题记录表=======================================================================
        htrq.setDuration(duration + htrq.getDuration());
        /* 答案:我的 */
        htrq.setAnswerOfMy(answerOfMy);
        /* 答案:题的 */
        String answerOfQues = this.GetAnswerOfQuest(homeworkTaskQues);
        if (StringUtils.isBlank(answerOfQues)) {// 如果记录中题的信息为空，解析题的正确答案，并输入
            answerOfQues = GetAnswerOfQuest(homeworkTaskQues);
            htrq.setAnswerOfQues(answerOfQues);
            Assert.isTrue(StringUtils.isBlank(answerOfQues), "答案解析失败，请联系管理员！！");
        }
        /* 是否正确 0-错误 , 1-正确 */
        if (answerOfQues.equals(answerOfMy)) {
            htrq.setPassed(1);
            htrq.setMark(5);
        } else {
            htrq.setPassed(0);
            htrq.setMark(0);
            /* 学生点击删除，将此题在错题本中不显示。 (0:已删除;1:未删除)(只针对错题) */
            htrq.setIsView(1);
        }
        htrqr.save(htrq);
        // 更新任务报告表================================================================
        // 做题时长
        // Long durations = 0l;
        // durations = htr.getDuration() + duration;
        // // 设置当前做题时长
        // htr.setDuration(durations);
        // htrr.save(htr);

        return true;
    }

    // 当学生第一次请求的时候，构建学生的答题记录 2017年4月21日11:56:47 重构
    @Override
    public boolean buildAnswers(String studentId, String taskId) {
        // 获取当前任务的信息
        HomeworkTask homeworkTask = htr.findOne(taskId);
        Assert.notNull(homeworkTask, "作业信息获取失败");
        // 获取当前学生的作业报告信息
        HomeworkTaskReport homeworkTaskReport = htrr.findByStudentIdAndTaskId(studentId, taskId);
        Assert.notNull(homeworkTaskReport, "获取当前学生的作业报告信息失败，请联系管理员");
        List<HomeworkTaskQues> homeworkTaskQuess = htqr.findByTaskId(taskId);// 当前任务所有题
        // 循环创建答题记录
        HomeworkTaskReportQues homeworkTaskReportQues;
        for (HomeworkTaskQues homeworkTaskQues : homeworkTaskQuess) {

            // 新建答题记录================================================
            homeworkTaskReportQues = new HomeworkTaskReportQues();
            /* 任务:ID */
            homeworkTaskReportQues.setTaskId(homeworkTaskReport.getTaskId());
            /* 任务名称 */
            homeworkTaskReportQues.setTitle(homeworkTaskReport.getTitle());
            /* 报告:ID */
            // String reportId;
            homeworkTaskReportQues.setReportId(homeworkTaskReport.getId());
            /* 发布用户:ID */
            homeworkTaskReportQues.setPublishUserId(homeworkTask.getPublishUserId());
            /* 发布用户名称 */
            homeworkTaskReportQues.setPublishUserNick(homeworkTask.getPublishUserNick());
            /* 学校id */
            homeworkTaskReportQues.setSchoolId(homeworkTask.getSchoolId());
            /* 学生:ID */
            // String studentId;
            homeworkTaskReportQues.setStudentId(studentId);
            /* 学生:姓名 */
            // String studentName;
            homeworkTaskReportQues.setStudentName(homeworkTaskReport.getStudentNick());
            /* 班级id */
            try {
                homeworkTaskReportQues.setClassId(homeworkTaskReport.getClassId());
            } catch (Exception e) {
                e.printStackTrace();
                // Assert.isTrue(false, "找不到对应的班级");
            }
            /* 学段 */
            homeworkTaskReportQues.setStage(homeworkTask.getStage());
            /* 学科 */
            homeworkTaskReportQues.setSubject(homeworkTask.getSubject());
            /* 试题:ID */
            homeworkTaskReportQues.setQuesId(homeworkTaskQues.getQuesId());
            /* 试题类型，使用题库中的的类型 （0--单选择题，1--多选择题，2--通知类） */
            homeworkTaskReportQues.setQuestionType(homeworkTaskQues.getQuesType());
            /* 知识点:ID */
            homeworkTaskReportQues.setKnowIdLst(homeworkTaskQues.getKnowId());
            /* 知识点:Name */
            homeworkTaskReportQues.setKnowNameLst(homeworkTaskQues.getKnowName());
            /* 难度系数 */
            homeworkTaskReportQues.setDifficultyXs(homeworkTaskQues.getDifficultyXs());
            /* 难度级别:1-易,2-中,3-难 */
            homeworkTaskReportQues.setDifficultyLevel(homeworkTaskQues.getDifficultyLevel());
            /* 主观题目的回答 */
            homeworkTaskReportQues.setAnswerText("");
            /* 选择题答案:我的 */
            homeworkTaskReportQues.setAnswerOfMy("");
            /* 答案:题的 */
            String answerOfQues = GetAnswerOfQuest(homeworkTaskQues);
            homeworkTaskReportQues.setAnswerOfQues(answerOfQues);
            /* 是否正确 0-错误 , 1-正确 */
            homeworkTaskReportQues.setPassed(0);
            /* 学生点击删除，将此题在错题本中不显示。 (0:已删除;1:未删除)(只针对错题) */
            homeworkTaskReportQues.setIsView(1);
            /* 做题时间 */
            homeworkTaskReportQues.setDuration(0);
            /* 当前时间 */
            homeworkTaskReportQues.setDate(DateAndLocalDateConvertUtils.asLocalDate(new Date()));
            /* 任务中题的序号 */
            homeworkTaskReportQues.setOrder(homeworkTaskQues.getOrder());
            homeworkTaskReportQues.setCreatedDate(new Timestamp(new Date().getTime()));
            homeworkTaskReportQues.setCreatedBy(studentId);
            htrqr.save(homeworkTaskReportQues);
        }
        // 修改任务报告表================================================
        // 设置当前做题时长
        homeworkTaskReport.setDuration(0l);
        // 设置任务状态
        homeworkTaskReport.setStatusOfFinished(3);
        htrr.save(homeworkTaskReport);

        return true;
    }

    // 用户提交一道 主观题 2017 年4月21日10:57:18 重构
    @Override
    public boolean saveHomeworkForZG(String studentId, String quesId, String answerOfMy, Integer duration,
            String taskId, List<String> answerImgs) {
        // 获取当前题的信息
        HomeworkTaskQues homeworkTaskQues = htqr.findByQuesIdAndTaskId(quesId, taskId).get(0);
        Assert.notNull(homeworkTaskQues, "提交的题没有找到！");
        // 获取当前任务的信息
        HomeworkTask homeworkTask = htr.findOne(taskId);
        Assert.notNull(homeworkTask, "作业信息获取失败");
        // 获取当前学生的作业报告信息
        HomeworkTaskReport htr = htrr.findByStudentIdAndTaskId(studentId, taskId);
        Assert.notNull(htr, "获取当前学生的作业报告信息失败，请联系管理员");
        // 判断学生是否已经提交作业
        HomeworkTaskReportQues htrq = htrqr.findByStudentIdAndTaskIdAndQuesId(studentId, taskId, quesId);
        // Assert.isTrue(htr.getStatusOfFinished() == 3 , "当前作业不是答题状态，无法提交");

        if (htrq != null) { // 已存在记录，更新
            // 根据作业类型,进行判断正误（选择题）或直接保存（通知类作业）
            /* 做题时间 */
            htrq.setDuration(duration + htrq.getDuration());
            // 做题时长
            // Long durations = 0l;
            // durations = htr.getDuration() + duration;
            // // 设置当前做题时长
            // htr.setDuration(durations);
            //
            // htrr.save(htr);
            // 保存主观题作业
            htrq.setAnswerText(answerOfMy);
            // 保存图片
            htrq.setAnswerImgs(answerImgs);
            htrq.setLastModifiedDate(new Timestamp(new Date().getTime()));
            htrq.setLastModifiedBy(studentId);
            htrqr.save(htrq);
        } else { // 未存在记录，插入
            // 创建新的答题记录
            htrq = buildWorkLog(studentId, quesId, answerOfMy, duration, homeworkTaskQues, homeworkTask, htr);
            htrqr.save(htrq);
        }
        return true;
    }

    // 用户提交一道 阅读题 2017年8月31日16:00:57
    @Override
    public boolean saveHomeworkForYD(String studentId, String quesId, Integer duration, Integer lookTime, String taskId,
            Integer index) {
        // 获取当前题的信息
        HomeworkTaskQues homeworkTaskQues = htqr.findByQuesIdAndTaskId(quesId, taskId).get(0);
        Assert.notNull(homeworkTaskQues, "提交的题没有找到！");
        // 获取当前任务的信息
        HomeworkTask homeworkTask = htr.findOne(taskId);
        Assert.notNull(homeworkTask, "作业信息获取失败");
        // 获取当前学生的作业报告信息
        HomeworkTaskReport htr = htrr.findByStudentIdAndTaskId(studentId, taskId);
        Assert.notNull(htr, "获取当前学生的作业报告信息失败，请联系管理员");
        // 判断学生是否已经提交作业
        HomeworkTaskReportQues htrq = htrqr.findByStudentIdAndTaskIdAndQuesId(studentId, taskId, quesId);
        // Assert.isTrue(htr.getStatusOfFinished() == 3 , "当前作业不是答题状态，无法提交");

        if (htrq != null) { // 已存在记录，更新
            // 保存答题时长
            List<Article> quesArticle = htrq.getQuesArticle();
            if (quesArticle == null) {
                quesArticle = homeworkTaskQues.getQuesArticle();
                // 初始化答题时长
                for (Article article : quesArticle) {
                    article.setDuration(0);
                }
                // 设置答题时长
                quesArticle.get(index).setDuration(lookTime);
            }
            // 设置答题时长
            quesArticle.get(index).setDuration(lookTime + quesArticle.get(index).getDuration());
            htrq.setQuesArticle(quesArticle);
            htrq.setLastModifiedDate(new Timestamp(new Date().getTime()));
            htrq.setLastModifiedBy(studentId);
            /* 做题时间 */
            Integer timeInteger = 0;
            for (Article article : quesArticle) {
                timeInteger += article.getDuration();
            }
            htrq.setDuration(timeInteger);
            htrqr.save(htrq);

            // 当前作业做题时长 已修改逻辑，提交时计算得出时长
            // Long durations = 0l;
            // durations = htr.getDuration() + duration;
            // htr.setDuration(durations);
            // htrr.save(htr);
        } else { // 未存在记录，插入
            // 创建新的答题记录
            htrq = buildWorkLog(studentId, quesId, "", lookTime, homeworkTaskQues, homeworkTask, htr);
            List<Article> quesArticle = homeworkTaskQues.getQuesArticle();
            // 初始化答题时长
            for (Article article : quesArticle) {
                article.setDuration(0);
            }
            // 设置答题时长
            quesArticle.get(index).setDuration(lookTime);
            htrqr.save(htrq);
        }
        return true;
    }

    /*
     * 作业提交时的方法 2017年5月3日10:26:00
     */
    @Override
    public Boolean commitHomework(String studentId, String taskId, String homeworkType) {
        // 判断作业是否可以提交
        HomeworkTaskReport homeworkTaskReport = htrr.findByStudentIdAndTaskId(studentId, taskId);
        Assert.notNull(homeworkTaskReport, "当前作业的任务未找到！");
        Assert.isTrue(homeworkTaskReport.getStatusOfFinished() == 3, "当前作业不是答题状态，无法提交");
        // 查询当前任务下的作业
        List<HomeworkTaskReportQues> htrqsnot2 = htrqr.findByStudentIdAndTaskId(studentId, taskId);
        // 添加作业知识点学生表
        HomeworkTask task = htr.findOne(homeworkTaskReport.getTaskId());
        Assert.notNull(task, "作业报告中未找到作业信息");
        List<Integer> knowIds = task.getKnowIds();
        List<String> knowNames = task.getKnowNames();
        Assert.isTrue(knowIds.size() == knowNames.size(), "作业报告中知识点ID和知识点名称不对应");
        // 修改 作业:知识点:学生表
        changeHomeworkKnowReport(studentId, taskId, homeworkTaskReport, htrqsnot2, knowIds, knowNames);
        // 修改作业任务报告表
        homeworkTaskReport.setStatusOfFinished(1);
        homeworkTaskReport.setFinishedDate(new Date());
        Long taskDuration = getTaskDuration(htrqsnot2);
        homeworkTaskReport.setDuration(taskDuration);
        htrr.save(homeworkTaskReport);
        // 修改作业班级对应表中的完成总人数
        changeFinishMans(taskId, homeworkTaskReport.getClassId());
        // 自动批阅选择题
        homeworkCorrect1Service.correct(taskId, homeworkTaskReport.getClassId(), studentId);
        return true;

    }

    private Long getTaskDuration(List<HomeworkTaskReportQues> htrqsnot2) {
        long num = 0l;
        for (HomeworkTaskReportQues homeworkTaskReportQues : htrqsnot2) {
            num += homeworkTaskReportQues.getDuration();
        }
        return num;
    }

    // 修改当前的已提交总人数和已批阅人数 2017年5月3日10:26:05
    private void changeFinishMans(String taskId, String classId) {
        HomeworkTaskClass htc = htcr.findTop1ByTaskIdAndClassId(taskId, classId);
        // 获得当前已提交的和已批阅的人数
        // 已提交人数
        Integer tj = htrr.countByClassIdAndTaskIdAndStatusOfFinished(classId, taskId, 1);
        // 已批阅人数
        Integer py = htrr.countByClassIdAndTaskIdAndStatusOfFinished(classId, taskId, 2);
        // 修改已提交人数
        htc.setSubmitOfStudent(tj + py);
        htcr.save(htc);
    }

    /*
     * 查询到目前为止，任务的做题时长2017年3月22日16:38:55
     */
    @Override
    public Long getDuration(String studentId, String taskId) {
        HomeworkTaskReport homeworkTaskReport = htrr.findByStudentIdAndTaskId(studentId, taskId);
        return homeworkTaskReport.getDuration();
    }

    // 作业:知识点:学生表--修改
    private void changeHomeworkKnowReport(String studentId, String taskId, HomeworkTaskReport homeworkTaskReport,
            List<HomeworkTaskReportQues> htrqs, List<Integer> knowIds, List<String> knowNames) {
        /*
         * int tag; for (int i = 0; i < knowIds.size(); i++) {
         * HomeworkKnowReport hkr = new HomeworkKnowReport();
         * hkr.setStudentId(studentId); hkr.setTaskId(taskId); tag =
         * knowIds.get(i); hkr.setKnowId(tag);
         * hkr.setKnowName(knowNames.get(i));
         * hkr.setSchoolId(homeworkTaskReport.getSchoolId());
         * hkr.setClassId(homeworkTaskReport.getClassId()); // 包含有该知识点的题 int
         * numHave = 0; double numHaveAndRight = 0; // 遍历所有当前任务下的非通知类的作业 for
         * (HomeworkTaskReportQues htrq : htrqs) { if
         * (htrq.getQuestionType().equals("2")) { break; } List<Integer>
         * knowIdLst = htrq.getKnowIdLst(); for (Integer knowId : knowIdLst) {
         * if (knowId == tag) { numHave++; if (htrq.getPassed() == 1) {
         * numHaveAndRight++; } } } } if (numHave == 0 || numHaveAndRight == 0)
         * { hkr.setRate(0D); } else { hkr.setRate((numHaveAndRight / numHave) *
         * 100); } hkrr.save(hkr); }
         */
    }

    // // 修改作业任务报告表
    // private HomeworkTaskReport changeTaskReport(String studentId, String
    // taskId, String homeworkType,
    // HomeworkTaskReport homeworkTaskReport) {
    // // 一次提交的情况就直接提交
    // homeworkTaskReport.setStatusOfFinished(1);
    // // // 当前状态为纯选择题的时候，需要进行自动批阅并且自动计算正确率
    // // if ("0".equals(homeworkTaskReport.getTaskType())) {
    // // homeworkTaskReport.setStatusOfFinished(2);
    // // // getRightRate(studentId, taskId, homeworkTaskReport);
    // // }
    // // homeworkTaskReport.setFinishedDate(new Date());
    // return homeworkTaskReport;
    // }

    /*
     * 学生答题时间结束后自动提交学生未答题
     */
    @Override
    public void timeOver(String studentId, String taskId) {

        // // 将当前任务下，学生未答题自动提交
        // List<HomeworkTaskQues> allQuestList = htqr.findByTaskId(taskId);//
        // 当前任务所有题
        //
        // List<HomeworkTaskReportQues> htrqs =
        // htrqr.findByStudentIdAndTaskIdAndQuestionTypeNotIn(studentId, taskId,
        // "-1");
        //
        // if (htrqs.size() < allQuestList.size()) {//
        // 如果学生答题小于任务所有题的时候，说明存在没有提交的题
        // for (HomeworkTaskQues sytjl : allQuestList) {// 所有题记录
        // boolean isdo = false;
        // for (int i = 0; i < htrqs.size(); i++) {// 学生答题记录
        // if (sytjl.getQuesId().equals(htrqs.get(i).getQuesId())) {
        // isdo = true;
        // break;
        // }
        // }
        // if (!isdo && !sytjl.getQuesType().equals("2")) {
        // String quesId = sytjl.getQuesId(); // 获取当前题的信息
        // HomeworkTaskQues homeworkTaskQues =
        // htqr.findByQuesIdAndTaskId(quesId, taskId).get(0);
        // Assert.notNull(homeworkTaskQues, "提交的题没有找到！"); // 获取当前任务的信息
        // HomeworkTask homeworkTask = htr.findOne(taskId);
        // Assert.notNull(homeworkTask, "作业信息获取失败"); // 获取当前学生的作业报告信息
        // HomeworkTaskReport htr = htrr.findByStudentIdAndTaskId(studentId,
        // taskId);
        // Assert.notNull(htr, "获取当前学生的作业报告信息失败，请联系管理员"); //
        // // 判断学生是否有权限提交
        // HomeworkTaskReportQues htrq =
        // htrqr.findByStudentIdAndTaskIdAndQuesId(studentId, taskId, quesId);
        // if (htrq != null) { // 已存在记录，更新 //
        // // 根据作业类型,进行判断正误（选择题）或直接保存（通知类作业）
        // // 做题时间
        // htrq.setDuration(0);
        // // 做题时长
        // Long durations = 0l;
        // durations = htr.getDuration() + 0;
        // // 设置当前做题时长
        // htr.setDuration(durations);
        // htrr.save(htr); // 根据作业类型,进行判断正误（选择题）或直接保存（通知类作业）
        // htrq = getType("", htrq, homeworkTaskQues);
        // htrq.setLastModifiedDate(new Timestamp(new Date().getTime()));
        // htrq.setLastModifiedBy(studentId);
        // htrqr.save(htrq);
        // } else { // 未存在记录，插入 // 创建新的答题记录
        // htrq = buildWorkLog(studentId, quesId, "", 0, homeworkTaskQues,
        // homeworkTask, htr);
        // htrqr.save(htrq);
        // }
        //
        // }
        // }
        // }

    }

    // 自动提交当前作业下，学生未答题

    // // 计算正确率
    // private void getRightRate(String studentId, String taskId,
    // HomeworkTaskReport homeworkTaskReport) {
    // // 单选题的总数
    // Long singleSelectQuest =
    // htrqr.countByStudentIdAndTaskIdAndQuestionType(studentId, taskId, "0");
    // // 多选题的总数
    // Long moreSelectQuest =
    // htrqr.countByStudentIdAndTaskIdAndQuestionType(studentId, taskId, "1");
    // // 做对的题的数量：单选
    // Long singleSelectRightQuest =
    // htrqr.countByStudentIdAndTaskIdAndQuestionTypeAndPassed(studentId,
    // taskId, "0",
    // 1);
    // // 做对的题的数量：多选
    // Long moreSelectRightQuest =
    // htrqr.countByStudentIdAndTaskIdAndQuestionTypeAndPassed(studentId,
    // taskId, "1", 1);
    // // 题的数量：总
    // Long allQuest = singleSelectQuest + moreSelectQuest;
    // if (allQuest == 0) {
    // // 正确率：总
    // homeworkTaskReport.setRightRate(0D);
    // homeworkTaskReport.setRightRate2(0D);
    // // 正确率：单选
    // homeworkTaskReport.setSingleSelectRighttRate(0D);
    // // 正确率：多选
    // homeworkTaskReport.setMoreSelectRightRate(0D);
    // } else {
    // Double numQuest = allQuest.doubleValue();
    //
    // // 做对的题的数量：总
    // Long allRightQuest = singleSelectRightQuest + moreSelectRightQuest;
    // // 正确率：总
    // homeworkTaskReport.setRightRate((allRightQuest / numQuest) * 100);
    // homeworkTaskReport.setRightRate2((allRightQuest / numQuest) * 100);
    // // 单选正确率
    // if (singleSelectQuest == 0) {
    // // 正确率：单选
    // homeworkTaskReport.setSingleSelectRighttRate(0D);
    // } else {
    // double numSingleSelectQuest = singleSelectQuest.doubleValue();
    // // 正确率：单选
    // homeworkTaskReport.setSingleSelectRighttRate((singleSelectRightQuest /
    // numSingleSelectQuest) * 100);
    // }
    //
    // // 多选正确率
    // if (moreSelectQuest == 0) {
    // // 正确率：多选
    // homeworkTaskReport.setMoreSelectRightRate(0D);
    // } else {
    // double numMoreSelectQuest = moreSelectQuest.doubleValue();
    // // 正确率：多选
    // homeworkTaskReport.setMoreSelectRightRate((moreSelectRightQuest /
    // numMoreSelectQuest) * 100);
    // }
    //
    // }
    // }

    // 构建答题记录
    private HomeworkTaskReportQues buildWorkLog(String studentId, String quesId, String answerOfMy, Integer duration,
            HomeworkTaskQues homeworkTaskQues, HomeworkTask homeworkTask, HomeworkTaskReport htr) {
        HomeworkTaskReportQues htrq;
        // 新建答题记录
        htrq = new HomeworkTaskReportQues();
        /* 任务:ID */
        htrq.setTaskId(homeworkTask.getId());
        /* 任务名称 */
        htrq.setTitle(homeworkTask.getTitle());
        /* 报告:ID */
        // String reportId;
        htrq.setReportId(htr.getId());
        /* 发布用户:ID */
        htrq.setPublishUserId(homeworkTask.getPublishUserId());
        /* 发布用户名称 */
        htrq.setPublishUserNick(homeworkTask.getPublishUserNick());
        /* 学校id */
        htrq.setSchoolId(homeworkTask.getSchoolId());
        /* 学生:ID */
        // String studentId;
        htrq.setStudentId(studentId);
        /* 学生:姓名 */
        // String studentName;
        htrq.setStudentName(htr.getStudentNick());
        /* 班级id */
        try {
            htrq.setClassId(htr.getClassId());
        } catch (Exception e) {
            e.printStackTrace();
            // Assert.isTrue(false, "找不到对应的班级");
        }
        /* 学段 */
        htrq.setStage(homeworkTask.getStage());
        /* 学科 */
        htrq.setSubject(homeworkTask.getSubject());
        /* 试题:ID */
        htrq.setQuesId(quesId);
        /* 试题类型，使用题库中的的类型 （0--单选择题，1--多选择题，2--通知类） */
        htrq.setQuestionType(homeworkTaskQues.getQuesType());
        /* 知识点:ID */
        htrq.setKnowIdLst(homeworkTaskQues.getKnowId());
        /* 知识点:Name */
        htrq.setKnowNameLst(homeworkTaskQues.getKnowName());
        /* 难度系数 */
        htrq.setDifficultyXs(homeworkTaskQues.getDifficultyXs());
        /* 难度级别:1-易,2-中,3-难 */
        htrq.setDifficultyLevel(homeworkTaskQues.getDifficultyLevel());
        // 根据作业类型,进行判断正误（选择题）或直接保存（通知类作业）
        htrq = getType(answerOfMy, htrq, homeworkTaskQues);

        /* 做题时间 */
        htrq.setDuration(0);
        // 设置当前做题时长
        htr.setDuration(0l);

        htrr.save(htr);
        /* 当前时间 */
        htrq.setDate(DateAndLocalDateConvertUtils.asLocalDate(new Date()));
        /* 任务中题的序号 */
        htrq.setOrder(homeworkTaskQues.getOrder());
        htrq.setCreatedDate(new Timestamp(new Date().getTime()));
        htrq.setCreatedBy(studentId);
        return htrq;
    }

    // 根据作业类型,进行判断正误（选择题）或直接保存（通知类作业）
    private HomeworkTaskReportQues getType(String answerOfMy, HomeworkTaskReportQues htrq,
            HomeworkTaskQues homeworkTaskQues) {
        // 判断当前题目的类型
        if ("2".equals(homeworkTaskQues.getQuesType())) {
            /* 通知类题目的回答 */
            htrq.setAnswerText(answerOfMy);
        } else if ("3".equals(homeworkTaskQues.getQuesType())) {
            /* 填空类题目的回答 */
            htrq.setAnswerText(answerOfMy);
        } else if ("4".equals(homeworkTaskQues.getQuesType())) {
            /* 问答类题目的回答 */
            htrq.setAnswerText(answerOfMy);
        } else {
            /* 答案:我的 ；可能为空，因为主观题为图片链接 <br/> 多选题，使用A，B 存储 */
            htrq.setAnswerOfMy(answerOfMy);
            /* 答案:题的 */
            String answerOfQues = GetAnswerOfQuest(homeworkTaskQues);
            htrq.setAnswerOfQues(answerOfQues);
            /* 是否正确 0-错误 , 1-正确 */
            if (answerOfQues.equals(answerOfMy)) {
                htrq.setPassed(1);
                htrq.setMark(5);
            } else {
                htrq.setPassed(0);
                htrq.setMark(0);
                /* 学生点击删除，将此题在错题本中不显示。 (0:已删除;1:未删除)(只针对错题) */
                htrq.setIsView(1);
            }

        }
        return htrq;
    }

    // 获取当前题的正确答案
    private String GetAnswerOfQuest(HomeworkTaskQues homeworkTaskQues) {
        if ("0".equals(homeworkTaskQues.getQuesType()) || "1".equals(homeworkTaskQues.getQuesType())) {
            // 获取题的信息
            String answerOfQues = "";
            ElasticYxyYxyQuesResource elasticYxyYxyQuesResource = elasticYxyYxyQuesResourceRespository
                    .findById(homeworkTaskQues.getQuesId());
            if (elasticYxyYxyQuesResource == null) { return ""; }
            // 题的答案数组
            List<Answer> answer = new ArrayList<AllTemplate.Answer>();
            try {
                AllTemplate quesBody = (AllTemplate) elasticYxyYxyQuesResource.getQuesBody();
                answer = quesBody.getSub().getAnswer();
            } catch (Exception e) {
                e.printStackTrace();
                Assert.isTrue(true, "解析试题信息失败");
            }
            // 单选题的情况下
            if ("0".equals(homeworkTaskQues.getQuesType())) {
                for (int i = 0; i < answer.size(); i++) {
                    answerOfQues += answer.get(i).getBody().charAt(0);
                }
            }
            // 多选的情况下

            if ("1".equals(homeworkTaskQues.getQuesType())) {
                for (int i = 0; i < answer.size(); i++) {
                    answerOfQues += answer.get(i).getBody();
                }
                String[] split = answerOfQues.split(",");
                String linshiString = "";
                for (int i = 0; i < split.length; i++) {
                    linshiString = linshiString + split[i].charAt(0) + ",";
                }
                answerOfQues = linshiString.substring(0, linshiString.length() - 1);
            }
            return answerOfQues;
        }
        return "";
    }

    @Override
    /*
     * 电子书包中学生提交一套作业的方法
     */
    public void ebagCommitHomeWork(String studentId, String taskId, String homeworkType) {
        // 判断作业是否可以提交
        HomeworkTaskReport homeworkTaskReport = htrr.findByStudentIdAndTaskId(studentId, taskId);
        Assert.notNull(homeworkTaskReport, "当前作业的任务未找到！");
        // 查询当前任务下的作业
        List<HomeworkTaskReportQues> htrqsnot2 = htrqr.findByStudentIdAndTaskId(studentId, taskId);
        // 添加作业知识点学生表
        HomeworkTask task = htr.findOne(homeworkTaskReport.getTaskId());
        Assert.notNull(task, "作业报告中未找到作业信息");
        List<Integer> knowIds = task.getKnowIds();
        List<String> knowNames = task.getKnowNames();
        Assert.isTrue(knowIds.size() == knowNames.size(), "作业报告中知识点ID和知识点名称不对应");
        // 修改 作业:知识点:学生表
        changeHomeworkKnowReport(studentId, taskId, homeworkTaskReport, htrqsnot2, knowIds, knowNames);
        // 修改作业任务报告表
        homeworkTaskReport.setStatusOfFinished(1);
        Long taskDuration = getTaskDuration(htrqsnot2);
        homeworkTaskReport.setDuration(taskDuration);
        homeworkTaskReport.setFinishedDate(new Date());
        htrr.save(homeworkTaskReport);
        // 修改作业班级对应表中的完成总人数
        changeFinishMans(taskId, homeworkTaskReport.getClassId());
        // 自动批阅选择题
        homeworkCorrect1Service.correct(taskId, homeworkTaskReport.getClassId(), studentId);
    }

}
